const DifyService = require('../utils/dify.service');
const Dify = require('../models/dify.model');  // 使用新的模型
const fs = require('fs');
const path = require('path');

class DifyController {
    // 创建新的 Dify 会话
    static async createSession(req, res) {
        try {
            const { sessionName } = req.body;
            const userId = req.user.userId;

            if (!sessionName) {
                return res.status(400).json({ 
                    message: '会话名称不能为空'
                });
            }

            const sessionId = await Dify.createSession(userId, sessionName);
            
            res.status(201).json({
                message: '会话创建成功',
                sessionId,
                sessionName
            });
        } catch (error) {
            console.error('创建Dify会话错误:', error);
            res.status(500).json({ message: '服务器错误' });
        }
    }

    // 发送消息到 Dify
    static async sendMessage(req, res) {
        try {
            const sessionId = req.body.sessionId;
            const message = req.body.message;
            const userId = req.user.userId;
            const file = req.files?.file?.[0];

            if (!sessionId || !message) {
                return res.status(400).json({
                    error: '缺少必要参数'
                });
            }

            // 验证会话存在并获取 dify_conversation_id
            const session = await Dify.getSessionById(sessionId, userId);
            if (!session) {
                return res.status(404).json({ error: '会话不存在' });
            }

            console.log('当前会话信息:', {
                sessionId,
                userId,
                conversationId: session.conversation_id_dify,
                hasFile: !!file
            });

            if (file) {
                // 确保 uploads 目录存在
                const uploadsDir = path.join(__dirname, '../../public/uploads');
                if (!fs.existsSync(uploadsDir)) {
                    fs.mkdirSync(uploadsDir, { recursive: true });
                }

                // 生成唯一文件名
                const timestamp = Date.now();
                const uniqueFileName = `${timestamp}-${file.originalname}`;
                const filePath = path.join(uploadsDir, uniqueFileName);

                // 保存文件
                await fs.promises.writeFile(filePath, file.buffer);
                console.log('文件已保存到:', filePath);

                // 更新图片URL
                const imageUrl = `/uploads/${uniqueFileName}`;
                
                // 保存用户消息时使用这个URL
                await Dify.saveMessage(
                    sessionId, 
                    userId, 
                    'user', 
                    message,
                    null,
                    null,
                    null,
                    imageUrl  // 保存可访问的图片URL
                );
            } else {
                // 没有文件的情况
                await Dify.saveMessage(
                    sessionId,
                    userId,
                    'user',
                    message
                );
            }

            // 设置SSE响应头
            res.setHeader('Content-Type', 'text/event-stream');
            res.setHeader('Cache-Control', 'no-cache');
            res.setHeader('Connection', 'keep-alive');

            try {
                let fullResponse = '';
                let currentMessageId = '';
                let currentConversationId = '';
                let messageComplete = false;

                const handleProgress = (chunk) => {
                    res.write(chunk);
                    try {
                        const data = JSON.parse(chunk.slice(6));
                        
                        switch (data.event) {
                            case 'agent_message':
                                currentMessageId = data.message_id;
                                currentConversationId = data.conversation_id;
                                if (data.answer) {
                                    fullResponse += data.answer;
                                }
                                break;
                            case 'message_end':
                                messageComplete = true;
                                // 如果是新会话，保存 conversation_id
                                if (currentConversationId && !session.conversation_id_dify) {
                                    console.log('保存新的会话ID:', currentConversationId);
                                    Dify.updateConversationId(sessionId, currentConversationId)
                                        .then(() => console.log('会话ID更新成功'))
                                        .catch(err => console.error('更新会话ID失败:', err));
                                }
                                // 保存AI回复
                                if (fullResponse) {
                                    Dify.saveMessage(
                                        sessionId, 
                                        userId, 
                                        'assistant', 
                                        fullResponse,
                                        currentMessageId,
                                        data.metadata,
                                        currentConversationId,
                                        null  // AI回复不需要图片路径
                                    ).then(() => {
                                        console.log('AI回复已保存到数据库');
                                    }).catch(err => {
                                        console.error('保存AI回复失败:', err);
                                    });
                                }
                                break;
                        }
                    } catch (e) {
                        console.error('解析消息错误:', e);
                    }
                };

                // 获取AI响应，注意参数顺序
                const aiResponse = file 
                    ? await DifyService.getResponseWithLocalFile(
                        message,
                        file,
                        session.conversation_id_dify || "",
                        userId,
                        handleProgress
                    )
                    : await DifyService.getResponse(
                        message,
                        session.conversation_id_dify || "",
                        `user-${userId}`,
                        handleProgress
                    );

                res.end();
            } catch (aiError) {
                console.error('Dify服务错误:', aiError);
                res.write(`data: ${JSON.stringify({ error: aiError.message })}\n\n`);
                res.end();
            }
        } catch (error) {
            console.error('处理消息错误:', error);
            if (!res.headersSent) {
                res.status(500).json({ 
                    message: '服务器错误',
                    error: error.message 
                });
            }
        }
    }

    // 获取会话历史消息
    static async getMessages(req, res) {
        try {
            const { sessionId } = req.params;
            const userId = req.user.userId;

            const messages = await Dify.getMessages(sessionId, userId);
            res.json(messages);
        } catch (error) {
            console.error('获取消息历史错误:', error);
            res.status(500).json({ message: '服务器错误' });
        }
    }

    // 删除会话
    static async deleteSession(req, res) {
        try {
            const { sessionId } = req.params;
            const userId = req.user.userId;

            if (!sessionId) {
                return res.status(400).json({
                    error: '缺少会话ID'
                });
            }

            // 验证会话存在
            const session = await Dify.getSessionById(sessionId, userId);
            if (!session) {
                return res.status(404).json({ 
                    error: '会话不存在'
                });
            }

            // 删除会话
            await Dify.deleteSession(sessionId, userId);
            
            res.json({
                message: '会话删除成功',
                sessionId
            });
        } catch (error) {
            console.error('删除会话错误:', error);
            res.status(500).json({ 
                error: '删除会话失败',
                message: error.message 
            });
        }
    }

    // 重命名会话
    static async renameSession(req, res) {
        try {
            const { sessionId } = req.params;
            const { newName } = req.body;
            const userId = req.user.userId;

            if (!sessionId || !newName) {
                return res.status(400).json({
                    error: '缺少必要参数'
                });
            }

            // 验证会话存在
            const session = await Dify.getSessionById(sessionId, userId);
            if (!session) {
                return res.status(404).json({ 
                    error: '会话不存在'
                });
            }

            // 重命名会话
            await Dify.renameSession(sessionId, userId, newName);
            
            res.json({
                message: '会话重命名成功',
                sessionId,
                newName
            });
        } catch (error) {
            console.error('重命名会话错误:', error);
            res.status(500).json({ 
                error: '重命名会话失败',
                message: error.message 
            });
        }
    }

    // 获取所有会话
    static async getSessions(req, res) {
        try {
            const userId = req.user.userId;

            // 获取所有会话
            const sessions = await Dify.getSessions(userId);
            
            res.json({
                message: '获取会话列表成功',
                data: sessions
            });
        } catch (error) {
            console.error('获取会话列表错误:', error);
            res.status(500).json({ 
                error: '获取会话列表失败',
                message: error.message 
            });
        }
    }
}

module.exports = DifyController; 